/*
 * Copyright (C) 2008-2014 TrinityCore <http://www.trinitycore.org/>
 * Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */

/// \addtogroup Trinityd
/// @{
/// \file

#include "Common.h"
#include "ObjectMgr.h"
#include "World.h"
#include "Configuration/Config.h"

#include "CliRunnable.h"
#include "Log.h"
#include "Util.h"
#include "Threading/ThreadName.hpp"

#if PLATFORM != PLATFORM_WINDOWS
#include <readline/readline.h>
#include <readline/history.h>
#include <boost/algorithm/string/join.hpp>
#include <boost/algorithm/string/predicate.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <boost/range/adaptor/transformed.hpp>
#include <boost/range/any_range.hpp>
#include <string>
#include <vector>

#include "Chat/Command/CommandMgr.hpp"
#include "Chat/Command/Commands/MetaCommand.hpp"
#include "Chat/Command/Commands/RootCommand.hpp"

char* command_finder(const char* input, int state)
{
    // Note: Not sure if this is working as I'm not even sure if this code is enabled / used at all.
    static boost::any_range<chat::command::Command, boost::forward_traversal_tag>::iterator itr, end;
    static std::string hierarchyString, remainingString;

    if (state == 0)
    {
        // init
        chat::command::MetaCommand* command = &chat::command::CommandMgr::GetRootCommand();
        
        std::string_view in{ input };
        std::string_view hierarchy = in.substr(0, in.find_last_of(" "));
        std::string_view remaining = hierarchy.size() < in.size() ? in.substr(hierarchy.size()) : std::string_view{};

        std::vector<std::reference_wrapper<const std::string>> out{};
        for (
            size_t start = hierarchy.find_first_not_of(" "), end = std::min(hierarchy.find_first_of(" ", start), hierarchy.size());
            start != std::string_view::npos;
            start = hierarchy.find_first_not_of(" ", end), end = std::min(hierarchy.find_first_of(" ", start), hierarchy.size())
        ) {
            auto currName = hierarchy.substr(start, end - start);

            auto subCommand = command->GetSubCommand(currName);
            if (!subCommand)
                return nullptr;

            chat::command::MetaCommand* metaCommand = dynamic_cast<chat::command::MetaCommand*>(&subCommand.get());
            if (!metaCommand)
                return nullptr;

            out.emplace_back(metaCommand->GetName());
            command = metaCommand;
        }

        auto range = command->GetSubCommands();
        itr = range.begin();
        end = range.end();

        hierarchyString = boost::join(out | boost::adaptors::transformed([](auto ref) -> auto& { return ref.get(); }), " ");
        remainingString = std::string(remaining);
        boost::trim(remainingString);
    }

    while (itr != end)
    {
        if (boost::istarts_with(itr->GetName(), remainingString))
        {
            char* result = strdup((hierarchyString + " " + itr->GetName()).c_str());
            itr++;
            return result;
        }
        
        itr++;
    }

    return nullptr;
}

char** cli_completion(const char* text, int start, int /*end*/)
{
    char** matches = NULL;

    if (start)
        rl_bind_key('\t', rl_abort);
    else
        matches = rl_completion_matches((char*)text, &command_finder);
    return matches;
}

int cli_hook_func()
{
       if (World::IsStopped())
           rl_done = 1;
       return 0;
}

#endif

void utf8print(void* /*arg*/, const char* str)
{
#if PLATFORM == PLATFORM_WINDOWS
    wchar_t wtemp_buf[6000];
    size_t wtemp_len = 6000-1;
    if (!Utf8toWStr(str, strlen(str), wtemp_buf, wtemp_len))
        return;

    char temp_buf[6000];
    CharToOemBuffW(&wtemp_buf[0], &temp_buf[0], wtemp_len+1);
    printf(temp_buf);
#else
{
    printf("%s", str);
    fflush(stdout);
}
#endif
}

void commandFinished(void*, bool /*success*/)
{
    printf("TC> ");
    fflush(stdout);
}

#ifdef linux
// Non-blocking keypress detector, when return pressed, return 1, else always return 0
int kb_hit_return()
{
    struct timeval tv;
    fd_set fds;
    tv.tv_sec = 0;
    tv.tv_usec = 0;
    FD_ZERO(&fds);
    FD_SET(STDIN_FILENO, &fds);
    select(STDIN_FILENO+1, &fds, NULL, NULL, &tv);
    return FD_ISSET(STDIN_FILENO, &fds);
}
#endif

/// %Thread start
void CliThread()
{
    util::thread::nameing::SetName("CLI");

    ///- Display the list of available CLI functions then beep
    //TC_LOG_INFO("server.worldserver", "");
#if PLATFORM != PLATFORM_WINDOWS
    rl_attempted_completion_function = cli_completion;
    rl_event_hook = cli_hook_func;
#endif

    if (sConfigMgr->GetBoolDefault("BeepAtStart", true))
        printf("\a");                                       // \a = Alert

    // print this here the first time
    // later it will be printed after command queue updates
    printf("TC>");

    ///- As long as the World is running (no World::m_stopEvent), get the command line and handle it
    while (!World::IsStopped())
    {
        fflush(stdout);

        char *command_str ;             // = fgets(commandbuf, sizeof(commandbuf), stdin);

#if PLATFORM == PLATFORM_WINDOWS
        char commandbuf[256];
        command_str = fgets(commandbuf, sizeof(commandbuf), stdin);
#else
        command_str = readline("TC>");
        rl_bind_key('\t', rl_complete);
#endif

        if (command_str != NULL)
        {
            for (int x=0; command_str[x]; ++x)
                if (command_str[x] == '\r' || command_str[x] == '\n')
                {
                    command_str[x] = 0;
                    break;
                }

            if (!*command_str)
            {
#if PLATFORM == PLATFORM_WINDOWS
                printf("TC>");
#else
                free(command_str);
#endif
                continue;
            }

            std::string command;
            if (!consoleToUtf8(command_str, command))         // convert from console encoding to utf8
            {
#if PLATFORM == PLATFORM_WINDOWS
                printf("TC>");
#else
                free(command_str);
#endif
                continue;
            }

            fflush(stdout);
            sWorld->QueueCliCommand(new CliCommandHolder(NULL, command.c_str(), &utf8print, &commandFinished));
#if PLATFORM != PLATFORM_WINDOWS
            add_history(command.c_str());
            free(command_str);
#endif
        }
        else if (feof(stdin))
        {
            World::StopNow(SHUTDOWN_EXIT_CODE);
        }
    }
}
